//类型保护：通过判断去识别类型，核心就是类型的受窄
// js类型判断方式： typeof instanceof in
// ts类型判断方式（可辨识联合类型）：自定义类型保护（自己决定返回true的时候是什么类型） null保护（判断非空再去使用）
//除了上述这些类型，只要能通过结构来判断，都能达到类型判断的特性
//js类型判断demo:
//1、typeof
function double(val: number | string) {
    if (typeof val === "string") {
      val.charAt(0);
    } else {
      val.toFixed(2);
    }
  }
  //2、instanceof
  class Person {}
  class Dog {}
  function getInstance(clazz: new () => Dog | Person) {
    return new clazz();
  }
  let instance = getInstance(Person);
  if (instance instanceof Dog) {
    instance;
  } else {
    instance;
  }
  
  //3、in
  interface Bird {
    fly: string;
    kind: "niao";
  }
  interface Fish {
    swing: string;
    kind: "yu";
  }
  function getAnimal(animal: Bird | Fish) {
    if ("fly" in animal) {
      animal;
    } else {
      animal;
    }
  }
  //ts类型判断demo:
  //1、联合类型，共同属性
  function getAnimal2(animal: Bird | Fish) {
    if (animal.kind === "niao") {
      //联合类型，可以通过共同的属性，来识别类型
      animal;
    } else {
      animal;
    }
  }
  //2、animal is Bird：自定义类型保护
  function isBird(animal: Bird | Fish): animal is Bird {
    //animal is Bird，这个逻辑能帮助我们获取到返回值的类型
    return animal.kind === "niao";
  }
  function getAnimal3(animal: Bird | Fish) {
    if (isBird(animal)) {
      //判断逻辑抽离出去
      animal;
    } else {
      animal;
    }
  }
  
  //ts是静态语法检测
  const addPreFix = (num?: number) => {
    num = num || 100;
    num; //number
    function fn() {
      // return num + "人名币"; //ts是静态语法检测,无法检测执行函数内部的num类型，所以结果是：number | undefined
      if(num){
          return num + "人名币"; //number
      }
    }
    return fn();
  };
  const dd=addPreFix();
  function ensureArray<T>(p:T | T[]):T[]{
      if(Array.isArray(p)){
          return p
      }else{
          return [p]
      }
  
  }
  
  export {};
  